<?xml version='1.0' encoding='UTF-8'?>
<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Transitional//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd'>
<html dir="ltr" xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>JSON-LD - Linked Data Expression in JSON</title>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />

<!--  
  === NOTA BENE ===
  For the three scripts below, if your spec resides on dev.w3 you can check them
  out in the same tree and use relative links so that they'll work offline,
   -->



<style>
.diff { font-weight:bold; color:#0a3; }
</style>
<style type="text/css">
/*****************************************************************
 * ReSpec CSS
 * Robin Berjon (robin at berjon dot com)
 * v0.05 - 2009-07-31
 *****************************************************************/


/* --- INLINES --- */
em.rfc2119 { 
    text-transform:     lowercase;
    font-variant:       small-caps;
    font-style:         normal;
    color:              #900;
}

h1 acronym, h2 acronym, h3 acronym, h4 acronym, h5 acronym, h6 acronym, a acronym,
h1 abbr, h2 abbr, h3 abbr, h4 abbr, h5 abbr, h6 abbr, a abbr {
    border: none;
}

dfn {
    font-weight:    bold;
}

a.internalDFN {
    color:  inherit;
    border-bottom:  medium solid #99c;
    text-decoration:    none;
}

a.externalDFN {
    color:  inherit;
    border-bottom:  medium dotted #ccc;
    text-decoration:    none;
}

a.bibref {
    text-decoration:    none;
}

code {
    color:  #ff4500;
}


/* --- WEB IDL --- */
pre.idl {
    border-top: 1px solid #90b8de;
    border-bottom: 1px solid #90b8de;
    padding:    1em;
    line-height:    120%;
}

pre.idl::before {
    content:    "WebIDL";
    display:    block;
    width:      150px;
    background: #90b8de;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

.idlType {
    color:  #ff4500;
    font-weight:    bold;
    text-decoration:    none;
}

/*.idlModule*/
/*.idlModuleID*/
/*.idlInterface*/
.idlInterfaceID {
    font-weight:    bold;
    color:  #005a9c;
}

.idlSuperclass {
    font-style: italic;
    color:  #005a9c;
}

/*.idlAttribute*/
.idlAttrType, .idlFieldType {
    color:  #005a9c;
}
.idlAttrName, .idlFieldName {
    color:  #ff4500;
}
.idlAttrName a, .idlFieldName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlMethod*/
.idlMethType {
    color:  #005a9c;
}
.idlMethName {
    color:  #ff4500;
}
.idlMethName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlParam*/
.idlParamType {
    color:  #005a9c;
}
.idlParamName {
    font-style: italic;
}

.extAttr {
    color:  #666;
}

/*.idlConst*/
.idlConstType {
    color:  #005a9c;
}
.idlConstName {
    color:  #ff4500;
}
.idlConstName a {
    color:  #ff4500;
    border-bottom:  1px dotted #ff4500;
    text-decoration: none;
}

/*.idlException*/
.idlExceptionID {
    font-weight:    bold;
    color:  #c00;
}

.idlTypedefID, .idlTypedefType {
    color:  #005a9c;
}

.idlRaises, .idlRaises a.idlType, .idlRaises a.idlType code, .excName a, .excName a code {
    color:  #c00;
    font-weight:    normal;
}

.excName a {
    font-family:    monospace;
}

.idlRaises a.idlType, .excName a.idlType {
    border-bottom:  1px dotted #c00;
}

.excGetSetTrue, .excGetSetFalse, .prmNullTrue, .prmNullFalse, .prmOptTrue, .prmOptFalse {
    width:  45px;
    text-align: center;
}
.excGetSetTrue, .prmNullTrue, .prmOptTrue { color:  #0c0; }
.excGetSetFalse, .prmNullFalse, .prmOptFalse { color:  #c00; }

.idlImplements a {
    font-weight:    bold;
}

dl.attributes, dl.methods, dl.constants, dl.fields {
    margin-left:    2em;
}

.attributes dt, .methods dt, .constants dt, .fields dt {
    font-weight:    normal;
}

.attributes dt code, .methods dt code, .constants dt code, .fields dt code {
    font-weight:    bold;
    color:  #000;
    font-family:    monospace;
}

.attributes dt code, .fields dt code {
    background:  #ffffd2;
}

.attributes dt .idlAttrType code, .fields dt .idlFieldType code {
    color:  #005a9c;
    background:  transparent;
    font-family:    inherit;
    font-weight:    normal;
    font-style: italic;
}

.methods dt code {
    background:  #d9e6f8;
}

.constants dt code {
    background:  #ddffd2;
}

.attributes dd, .methods dd, .constants dd, .fields dd {
    margin-bottom:  1em;
}

table.parameters, table.exceptions {
    border-spacing: 0;
    border-collapse:    collapse;
    margin: 0.5em 0;
    width:  100%;
}
table.parameters { border-bottom:  1px solid #90b8de; }
table.exceptions { border-bottom:  1px solid #deb890; }

.parameters th, .exceptions th {
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
    font-family:    initial;
    font-weight:    normal;
    text-shadow:    #666 1px 1px 0;
}
.parameters th { background: #90b8de; }
.exceptions th { background: #deb890; }

.parameters td, .exceptions td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
    vertical-align: top;
}

.parameters tr:first-child td, .exceptions tr:first-child td {
    border-top: none;
}

.parameters td.prmName, .exceptions td.excName, .exceptions td.excCodeName {
    width:  100px;
}

.parameters td.prmType {
    width:  120px;
}

table.exceptions table {
    border-spacing: 0;
    border-collapse:    collapse;
    width:  100%;
}

/* --- TOC --- */
.toc a {
    text-decoration:    none;
}

a .secno {
    color:  #000;
}

/* --- TABLE --- */
table.simple {
    border-spacing: 0;
    border-collapse:    collapse;
    border-bottom:  3px solid #005a9c;
}

.simple th {
    background: #005a9c;
    color:  #fff;
    padding:    3px 5px;
    text-align: left;
}

.simple th[scope="row"] {
    background: inherit;
    color:  inherit;
    border-top: 1px solid #ddd;
}

.simple td {
    padding:    3px 10px;
    border-top: 1px solid #ddd;
}

.simple tr:nth-child(even) {
    background: #f0f6ff;
}

/* --- DL --- */
.section dd > p:first-child {
    margin-top: 0;
}

.section dd > p:last-child {
    margin-bottom: 0;
}

.section dd {
    margin-bottom:  1em;
}

.section dl.attrs dd, .section dl.eldef dd {
    margin-bottom:  0;
}

/* --- EXAMPLES --- */
pre.example {
    border-top: 1px solid #ff4500;
    border-bottom: 1px solid #ff4500;
    padding:    1em;
    margin-top: 1em;
}

pre.example::before {
    content:    "Example";
    display:    block;
    width:      150px;
    background: #ff4500;
    color:  #fff;
    font-family:    initial;
    padding:    3px;
    font-weight:    bold;
    margin: -1em 0 1em -1em;
}

/* --- EDITORIAL NOTES --- */
.issue {
    padding:    1em;
    margin: 1em 0em 0em;
    border: 1px solid #f00;
    background: #ffc;
}

.issue::before {
    content:    "Issue";
    display:    block;
    width:  150px;
    margin: -1.5em 0 0.5em 0;
    font-weight:    bold;
    border: 1px solid #f00;
    background: #fff;
    padding:    3px 1em;
}

.note {
    margin: 1em 0em 0em;
    padding:    1em;
    border: 2px solid #cff6d9;
    background: #e2fff0;
}

.note::before {
    content:    "Note";
    display:    block;
    width:  150px;
    margin: -1.5em 0 0.5em 0;
    font-weight:    bold;
    border: 1px solid #cff6d9;
    background: #fff;
    padding:    3px 1em;
}

/* --- Best Practices --- */
div.practice {
    border: solid #bebebe 1px;
    margin: 2em 1em 1em 2em;
}

span.practicelab {
    margin: 1.5em 0.5em 1em 1em;
    font-weight: bold;
    font-style: italic;
}

span.practicelab   { background: #dfffff; }

span.practicelab {
    position: relative;
    padding: 0 0.5em;
    top: -1.5em;
}

p.practicedesc {
    margin: 1.5em 0.5em 1em 1em;
}

@media screen {
    p.practicedesc {
        position: relative;
        top: -2em;
        padding: 0;
        margin: 1.5em 0.5em -1em 1em;
}

/* --- SYNTAX HIGHLIGHTING --- */
pre.sh_sourceCode {
  background-color: white;
  color: black;
  font-style: normal;
  font-weight: normal;
}

pre.sh_sourceCode .sh_keyword { color: #005a9c; font-weight: bold; }           /* language keywords */
pre.sh_sourceCode .sh_type { color: #666; }                            /* basic types */
pre.sh_sourceCode .sh_usertype { color: teal; }                             /* user defined types */
pre.sh_sourceCode .sh_string { color: red; font-family: monospace; }        /* strings and chars */
pre.sh_sourceCode .sh_regexp { color: orange; font-family: monospace; }     /* regular expressions */
pre.sh_sourceCode .sh_specialchar { color: 	#ffc0cb; font-family: monospace; }  /* e.g., \n, \t, \\ */
pre.sh_sourceCode .sh_comment { color: #A52A2A; font-style: italic; }         /* comments */
pre.sh_sourceCode .sh_number { color: purple; }                             /* literal numbers */
pre.sh_sourceCode .sh_preproc { color: #00008B; font-weight: bold; }       /* e.g., #include, import */
pre.sh_sourceCode .sh_symbol { color: blue; }                            /* e.g., *, + */
pre.sh_sourceCode .sh_function { color: black; font-weight: bold; }         /* function calls and declarations */
pre.sh_sourceCode .sh_cbracket { color: red; }                              /* block brackets (e.g., {, }) */
pre.sh_sourceCode .sh_todo { font-weight: bold; background-color: #00FFFF; }   /* TODO and FIXME */

/* Predefined variables and functions (for instance glsl) */
pre.sh_sourceCode .sh_predef_var { color: #00008B; }
pre.sh_sourceCode .sh_predef_func { color: #00008B; font-weight: bold; }

/* for OOP */
pre.sh_sourceCode .sh_classname { color: teal; }

/* line numbers (not yet implemented) */
pre.sh_sourceCode .sh_linenum { display: none; }

/* Internet related */
pre.sh_sourceCode .sh_url { color: blue; text-decoration: underline; font-family: monospace; }

/* for ChangeLog and Log files */
pre.sh_sourceCode .sh_date { color: blue; font-weight: bold; }
pre.sh_sourceCode .sh_time, pre.sh_sourceCode .sh_file { color: #00008B; font-weight: bold; }
pre.sh_sourceCode .sh_ip, pre.sh_sourceCode .sh_name { color: #006400; }

/* for Prolog, Perl... */
pre.sh_sourceCode .sh_variable { color: #006400; }

/* for LaTeX */
pre.sh_sourceCode .sh_italics { color: #006400; font-style: italic; }
pre.sh_sourceCode .sh_bold { color: #006400; font-weight: bold; }
pre.sh_sourceCode .sh_underline { color: #006400; text-decoration: underline; }
pre.sh_sourceCode .sh_fixed { color: green; font-family: monospace; }
pre.sh_sourceCode .sh_argument { color: #006400; }
pre.sh_sourceCode .sh_optionalargument { color: purple; }
pre.sh_sourceCode .sh_math { color: orange; }
pre.sh_sourceCode .sh_bibtex { color: blue; }

/* for diffs */
pre.sh_sourceCode .sh_oldfile { color: orange; }
pre.sh_sourceCode .sh_newfile { color: #006400; }
pre.sh_sourceCode .sh_difflines { color: blue; }

/* for css */
pre.sh_sourceCode .sh_selector { color: purple; }
pre.sh_sourceCode .sh_property { color: blue; }
pre.sh_sourceCode .sh_value { color: #006400; font-style: italic; }

/* other */
pre.sh_sourceCode .sh_section { color: black; font-weight: bold; }
pre.sh_sourceCode .sh_paren { color: red; }
pre.sh_sourceCode .sh_attribute { color: #006400; }

</style><style type="text/css">ol.algorithm { counter-reset:numsection; list-style-type: none; }
ol.algorithm li { margin: 0.5em 0; }
ol.algorithm li:before { font-weight: bold; counter-increment: numsection; content: counters(numsection, ".") ") "; }

</style><link href="http://www.w3.org/StyleSheets/TR/w3c-unofficial" rel="stylesheet" type="text/css" charset="utf-8" /><style type='text/css'>
.diff-old-a {
  font-size: smaller;
  color: red;
}

.diff-new { background-color: yellow; }
.diff-chg { background-color: lime; }
.diff-new:before,
.diff-new:after
    { content: "\2191" }
.diff-chg:before, .diff-chg:after
    { content: "\2195" }
.diff-old { text-decoration: line-through; background-color: #FBB; }
.diff-old:before,
.diff-old:after
    { content: "\2193" }
:focus { border: thin red solid}
</style>
</head>
<body style="display: inherit; ">
<div class="head">
<p>
</p>
<h1 class="title" id="title">
JSON-LD
-
Linked
Data
Expression
in
JSON
</h1>
<h2 id="subtitle">
A
Context-based
JSON
Serialization
for
Linked
Data
</h2>
<h2 id="unofficial-draft-14-october-2010">
Unofficial
Draft
<del class="diff-old">23
September
</del>
<ins class="diff-chg">14
October
</ins>
2010
</h2>
<dl>
<dt>
Editor:
</dt>
<dd>
<a href="http://digitalbazaar.com/">
Manu
Sporny
</a>,
<a href="http://digitalbazaar.com/">
Digital
Bazaar,
Inc.
</a>
</dd>
<dt>
Authors:
</dt>
<dd>
<a href="http://webbackplane.com/">
Mark
Birbeck
</a>,
<a href="http://webbackplane.com/">
Backplane
Ltd.
</a>
</dd>
<dd>
<a href="http://digitalbazaar.com/">
Manu
Sporny
</a>,
<a href="http://digitalbazaar.com/">
Digital
Bazaar,
Inc.
</a>
</dd>
</dl>
<p>
<ins class="diff-new">This
document
is
also
available
in
this
non-normative
format:
</ins><a href="diff-20100823.html"><ins class="diff-new">
diff
to
previous
version
</ins></a>.</p>
<p class="copyright">
This
document
is
licensed
under
a
<a class="subfoot" href="http://creativecommons.org/licenses/by/3.0/" rel="license">
Creative
Commons
Attribution
3.0
License
</a>.
</p>
<hr />
</div>
<div id="abstract" class="introductory section">
<h2>
Abstract
</h2>
<p>
Developers
that
embed
structured
data
in
their
Web
pages
can
choose
among
a
number
of
languages
such
as
RDFa
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RDFA-CORE">
RDFA-CORE
</a>
</cite>
],
Microformats
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-MICROFORMATS">
MICROFORMATS
</a>
</cite>
]
and
Microdata
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-MICRODATA">
MICRODATA
</a>
</cite>
].
Each
of
these
structured
data
languages,
while
incompatible
at
the
syntax
level,
can
be
easily
mapped
to
RDF.
JSON
has
proven
to
be
a
highly
useful
object
serialization
and
messaging
replacement
for
SOAP.
In
an
attempt
to
harmonize
the
representation
of
Linked
Data
in
JSON,
this
specification
outlines
a
common
JSON
representation
format
for
Linked
Data
that
can
be
used
to
represent
objects
specified
via
RDFa,
Microformats
and
Microdata.
</p>
</div>
<div id="sotd" class="introductory section">
<h2>
Status
of
This
Document
</h2>
<p>
This
document
is
merely
a
public
working
draft
of
a
potential
specification.
It
has
no
official
standing
of
any
kind
and
does
not
represent
the
support
or
consensus
of
any
standards
organisation.
</p>
<p>
This
document
is
an
experimental
work
in
progress.
</p>
</div>
<div id="toc" class="section">
<h2 class="introductory">
Table
of
Contents
</h2>
<ul class="toc">
<li class="tocline">
<a href="#how-to-read-this-document" class="tocxref">
<span class="secno">
1.
</span>
How
to
Read
this
Document
</a>
</li>
<li class="tocline">
<a href="#introduction" class="tocxref">
<span class="secno">
2.
</span>
Introduction
</a>
</li>
<li class="tocline">
<a href="#design-goals" class="tocxref">
<span class="secno">
3.
</span>
Design
Goals
</a>
</li>
<li class="tocline">
<a href="#design-rationale" class="tocxref">
<span class="secno">
4.
</span>
Design
Rationale
</a>
<ul class="toc">
<li class="tocline">
<a href="#map-terms-to-iris" class="tocxref">
<span class="secno">
4.1
</span>
Map
Terms
to
IRIs
</a>
</li>
<del class="diff-old">4.2
The
Default
Context
</del>
</ul>
</li>
<li class="tocline">
<a href="#mashing-up-vocabularies" class="tocxref">
<span class="secno">
<del class="diff-old">4.3
</del>
<ins class="diff-chg">5.
</ins>
</span>
Mashing
Up
Vocabularies
</a>
</li>
<li class="tocline">
<a href="#an-example-of-a-default-context" class="tocxref">
<span class="secno">
<del class="diff-old">4.4
</del>
<ins class="diff-chg">6.
</ins>
</span>
An
Example
of
a
Default
Context
</a>
</li>
<li class="tocline">
<a href="#the-json-ld-processing-algorithm" class="tocxref">
<span class="secno">
<ins class="diff-new">7.
</ins></span><ins class="diff-new">
The
JSON-LD
Processing
Algorithm
</ins></a></li><li class="tocline">
<a href="#markup-examples" class="tocxref">
<span class="secno">
<del class="diff-old">4.5
</del>
<ins class="diff-chg">8.
</ins>
</span>
Markup
Examples
</a>
<ul class="toc">
<li class="tocline">
<a href="#rdfa" class="tocxref">
<span class="secno">
<del class="diff-old">4.5.1
</del>
<ins class="diff-chg">8.1
</ins>
</span>
RDFa
</a>
</li>
<li class="tocline">
<a href="#microformats" class="tocxref">
<span class="secno">
<del class="diff-old">4.5.2
</del>
<ins class="diff-chg">8.2
</ins>
</span>
Microformats
</a>
</li>
<li class="tocline">
<a href="#microdata" class="tocxref">
<span class="secno">
<del class="diff-old">4.5.3
</del>
<ins class="diff-chg">8.3
</ins>
</span>
Microdata
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#markup-of-rdf-concepts" class="tocxref">
<span class="secno">
<del class="diff-old">5.
</del>
<ins class="diff-chg">9.
</ins>
</span>
Markup
of
RDF
Concepts
</a>
<ul class="toc">
<li class="tocline">
<a href="#iris" class="tocxref">
<span class="secno">
<del class="diff-old">5.1
</del>
<ins class="diff-chg">9.1
</ins>
</span>
IRIs
</a>
</li>
<li class="tocline">
<a href="#identifying-the-subject" class="tocxref">
<span class="secno">
<del class="diff-old">5.2
</del>
<ins class="diff-chg">9.2
</ins>
</span>
Identifying
the
Subject
</a>
</li>
<li class="tocline">
<a href="#specifying-the-type" class="tocxref">
<span class="secno">
<del class="diff-old">5.3
</del>
<ins class="diff-chg">9.3
</ins>
</span>
Specifying
the
Type
</a>
</li>
<li class="tocline">
<a href="#plain-literals" class="tocxref">
<span class="secno">
<del class="diff-old">5.4
</del>
<ins class="diff-chg">9.4
</ins>
</span>
Plain
Literals
</a>
</li>
<li class="tocline">
<a href="#language-specification-in-plain-literals" class="tocxref">
<span class="secno">
<del class="diff-old">5.5
</del>
<ins class="diff-chg">9.5
</ins>
</span>
Language
Specification
in
Plain
Literals
</a>
</li>
<li class="tocline">
<a href="#typed-literals" class="tocxref">
<span class="secno">
<del class="diff-old">5.6
</del>
<ins class="diff-chg">9.6
</ins>
</span>
Typed
Literals
</a>
</li>
<li class="tocline">
<a href="#multiple-objects-for-a-single-property" class="tocxref">
<span class="secno">
<del class="diff-old">5.7
</del>
<ins class="diff-chg">9.7
</ins>
</span>
Multiple
Objects
for
a
Single
Property
</a>
</li>
<li class="tocline">
<a href="#multiple-typed-literals-for-a-single-property" class="tocxref">
<span class="secno">
<del class="diff-old">5.8
</del>
<ins class="diff-chg">9.8
</ins>
</span>
Multiple
Typed
Literals
for
a
Single
Property
</a>
</li>
<li class="tocline">
<a href="#blank-nodes" class="tocxref">
<span class="secno">
<del class="diff-old">5.9
</del>
<ins class="diff-chg">9.9
</ins>
</span>
Blank
Nodes
</a>
</li>
<li class="tocline">
<a href="#escape-character" class="tocxref">
<span class="secno">
<del class="diff-old">5.10
</del>
<ins class="diff-chg">9.10
</ins>
</span>
Escape
Character
</a>
</li>
<li class="tocline">
<a href="#automatic-typing" class="tocxref">
<span class="secno">
<del class="diff-old">5.11
</del>
<ins class="diff-chg">9.11
</ins>
</span>
Automatic
Typing
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#advanced-concepts" class="tocxref">
<span class="secno">
<ins class="diff-new">10.
</ins></span><ins class="diff-new">
Advanced
Concepts
</ins></a><ul class="toc"><li class="tocline"><a href="#disjoint-graphs" class="tocxref"><span class="secno"><ins class="diff-new">
10.1
</ins></span><ins class="diff-new">
Disjoint
Graphs
</ins></a></li><li class="tocline">
<a href="#acknowledgements" class="tocxref">
<span class="secno">
<del class="diff-old">A.
</del>
<ins class="diff-chg">10.2
</ins>
</span>
Acknowledgements
</a>
</li>
</ul>
</li>
<li class="tocline">
<a href="#references" class="tocxref">
<span class="secno">
<del class="diff-old">B.
</del>
<ins class="diff-chg">A.
</ins>
</span>
References
</a>
<ul class="toc">
<li class="tocline">
<a href="#normative-references" class="tocxref">
<span class="secno">
<del class="diff-old">B.1
</del>
<ins class="diff-chg">A.1
</ins>
</span>
Normative
references
</a>
</li>
<li class="tocline">
<a href="#informative-references" class="tocxref">
<span class="secno">
<del class="diff-old">B.2
</del>
<ins class="diff-chg">A.2
</ins>
</span>
Informative
references
</a>
</li>
</ul>
</li>
</ul>
</div>
<div id="how-to-read-this-document" class="section">
<h2>
<span class="secno">
1.
</span>
How
to
Read
this
Document
</h2>
<p>
This
document
is
a
detailed
specification
for
a
serialization
of
JSON
for
Linked
data.
The
document
is
primarily
intended
for
the
following
audiences:
</p>
<ul>
<li>
Developers
that
want
to
encode
Microformats,
RDFa,
or
Microdata
in
a
way
that
is
cross-language
compatible
via
JSON.
</li>
<li>
Developers
that
want
to
understand
the
encoding
possibilities.
</li>
</ul>
<p>
To
understand
this
specification
you
must
first
be
familiar
with
JSON,
which
is
detailed
in
[
<cite>
<a class="bibref" rel="biblioentry" href="#bib-RFC4627">
RFC4627
</a>
</cite>
].
</p>
</div>
<div id="introduction" class="section">
<h2>
<span class="secno">
2.
</span>
Introduction
</h2>
<p class="issue">
<del class="diff-old">Need
</del>
<ins class="diff-chg">Write
the
introduction
once
all
of
the
technical
details
are
hammered
out.
Explain
why
JSON-LD
is
designed
as
a
light-weight
mechanism
</ins>
to
<del class="diff-old">write
introduction...
</del>
<ins class="diff-chg">express
RDFa,
Microformats
and
Microdata.
It
is
primarily
intended
as
a
way
to
express
Linked
Data
in
Javascript
environments
as
well
as
a
way
to
pass
Linked
Data
to
and
from
Web
services.
It
is
designed
to
be
as
simple
as
possible,
utilizing
the
large
number
of
JSON
parsers
(and
understanding)
that
is
out
there
already.
It
is
designed
to
be
able
to
express
key-value
pairs,
RDF
data,
Microformats
data,
and
Microdata
(that
is,
every
data
model
currently
in
use)
using
one
unified
format.
It
does
not
require
anyone
to
change
their
JSON,
but
easily
add
meaning
by
adding
context
in
a
way
that
is
out-of-band
-
it
is
designed
to
not
disturb
already
deployed
systems
running
on
JSON,
but
provide
a
smooth
migration
path
from
JSON
to
JSON
with
added
semantics.
Finally,
the
format
is
intended
to
be
fast
to
parse,
fast
to
generate,
stream-based
and
document-based
processing
compatible,
and
require
a
tiny
memory
footprint
in
order
to
operate.
</ins>
</p>
</div>
<div id="design-goals" class="section">
<h2>
<span class="secno">
3.
</span>
Design
Goals
</h2>
<p>
A
number
of
design
considerations
were
explored
during
the
creation
of
this
markup
language:
</p>
<dl>
<dt>
Simplicity
</dt>
<dd>
Developers
don't
need
to
know
RDF
in
order
to
use
the
basic
functionality
provided
by
JSON-LD.
</dd>
<dt>
Compatibility
</dt>
<dd>
The
JSON-LD
markup
should
be
100%
compatible
with
JSON.
</dd>
<dt>
Expressiveness
</dt>
<dd>
All
major
RDF
concepts
must
be
expressible
via
the
JSON-LD
syntax.
</dd>
<dt>
Terseness
</dt>
<dd>
The
JSON-LD
syntax
must
be
very
terse
and
human
readable.
</dd>
<dt>
<ins class="diff-new">Zero
Edits
</ins></dt><dd><ins class="diff-new">
JSON-LD
provides
a
mechanism
that
allows
developers
to
specify
context
in
a
way
that
is
out-of-band.
This
allows
organizations
that
have
already
deployed
large
JSON-based
infrastructure
to
add
meaning
to
their
JSON
in
a
way
that
is
not
disruptive
to
their
day-to-day
operations
and
is
transparent
to
their
current
customers.
</ins></dd><dt><ins class="diff-new">
Streaming
</ins></dt><dd><ins class="diff-new">
The
format
supports
both
document-based
and
stream-based
processing.
</ins></dd>
</dl>
</div>
<div id="design-rationale" class="section">
<h2>
<span class="secno">
4.
</span>
Design
Rationale
</h2>
<p>
The
following
section
outlines
the
rationale
behind
the
JSON-LD
markup
language.
</p>
<div id="map-terms-to-iris" class="section">
<h3>
<span class="secno">
4.1
</span>
Map
Terms
to
IRIs
</h3>
<p>
Establishing
a
mechanism
to
map
JSON
values
to
IRIs
will
help
in
the
mapping
of
JSON
objects
to
RDF.
This
does
not
mean
that
JSON-LD
must
be
restrictive
in
declaring
a
set
of
terms,
rather,
experimentation
and
innovation
should
be
supported
as
part
of
the
core
design
of
JSON-LD.
There
are,
however,
a
number
of
very
small
design
criterial
that
can
ensure
that
developers
will
generate
good
RDF
data
that
will
create
value
for
the
greater
semantic
web
community
and
JSON/REST-based
Web
Services
community.
</p>
<p>
We
will
be
using
the
following
JSON
object
as
the
example
for
this
section:
</p>
<pre class="example">
<del class="diff-old">{"a" : "Person",
 "name" : "Manu Sporny",
"homepage"
:
"http://manu.sporny.org/"}
</del>
<ins class="diff-chg">{
  "a": "Person",
  "name": "Manu Sporny",
  "homepage": "http://manu.sporny.org/"
}
</ins>
</pre>
</div>
<del class="diff-old">4.2
</del>
<h3 id="the-default-context">
The
Default
Context
</h3>
<p>
A
default
context
is
used
in
RDFa
to
allow
developers
to
use
keywords
as
aliases
for
IRIs.
So,
for
instance,
the
keyword
<strong>
name
</strong>
above
could
refer
to
the
IRI
<em>
http://xmlns.com/foaf/0.1/name
</em>.
The
semantic
web,
just
like
the
document-based
web,
uses
IRIs
for
unambiguous
identification.
The
idea
is
that
these
terms
mean
something,
which
you
will
eventually
want
to
query.
The
semantic
web
specifies
this
via
<em>
Vocabulary
Documents
</em>.
The
IRI
<em>
http://xmlns.com/foaf/0.1/
</em>
specifies
a
Vocabulary
Document,
and
<strong>
name
</strong>
is
a
term
in
that
vocabulary.
Paste
the
two
items
together
and
you
have
an
unambiguous
identifier
for
a
term.
</p>
<p>
Developers,
and
machines,
would
be
able
to
use
this
IRI
(plugging
it
directly
into
a
web
browser,
for
instance)
to
go
to
the
term
and
get
a
definition
of
what
the
term
means.
Much
like
we
can
use
WordNet
today
to
see
the
<a href="http://wordnetweb.princeton.edu/perl/webwn?s=definition">
definition
</a>
of
words
in
the
English
language.
Machines
need
the
same
sort
of
dictionary
of
terms,
and
URIs
provide
a
way
to
ensure
that
these
terms
are
unambiguous.
</p>
<p>
Non-prefixed
terms
should
have
term
mappings
declared
in
the
default
context
so
that
they
may
be
expanded
later.
</p>
<p>
If
a
set
of
terms,
like
<strong>
Person
</strong>,
<strong>
name
</strong>,
and
<strong>
homepage
</strong>,
are
pre-defined
in
the
default
context,
and
that
context
is
used
to
resolve
the
names
in
JSON
objects,
machines
could
automatically
expand
the
terms
to
something
meaningful
and
unambiguous,
like
this:
</p>
<pre class="example">
<del class="diff-old">{"",
 "" : "Manu Sporny",
"
http://xmlns.com/foaf/0.1/homepage
"
:
"
&lt;
http://manu.sporny.org
&gt;
"}
</del>
<ins class="diff-chg">{
  "<span class="diff">http://www.w3.org/1999/02/22-rdf-syntax-ns#type</span>": "<span class="diff">http://xmlns.com/foaf/0.1/Person</span>",
  "<span class="diff">http://xmlns.com/foaf/0.1/name</span>": "Manu Sporny",
  "<span class="diff">http://xmlns.com/foaf/0.1/homepage</span>": "<span class="diff">&lt;</span>http://manu.sporny.org<span class="diff">&gt;</span>"
}
</ins>
</pre>
<p class="note">
In
order
to
differentiate
between
plain
text
and
IRIs,
the
<strong>
<
</strong> and <strong>
>
</strong>
are
used
around
IRIs.
</p>
<p>
Doing
this
would
mean
that
JSON
would
start
to
become
unambiguously
machine-readable,
play
well
with
the
semantic
web,
and
basic
markup
wouldn't
be
that
much
more
complex
than
basic
JSON
markup.
A
win,
all
around.
</p>
</div>
<div id="mashing-up-vocabularies" class="section">
<h2>
<span class="secno">
<del class="diff-old">4.3
</del>
<ins class="diff-chg">5.
</ins>
</span>
Mashing
Up
Vocabularies
</h2>
<p>
Developers
would
also
benefit
by
allowing
other
vocabularies
to
be
used
automatically
with
their
JSON
API.
There
are
over
200
Vocabulary
Documents
that
are
available
for
use
on
the
Web
today.
Some
of
these
vocabularies
are:
</p>
<ul>
<li>
XSD
-
for
specifying
basic
types
like
strings,
integers,
dates
and
times.
</li>
<li>
Dublin
Core
-
for
describing
creative
works.
</li>
<li>
FOAF
-
for
describing
social
networks.
</li>
<li>
Calendar
-
for
specifying
events.
</li>
<li>
SIOC
-
for
describing
discussions
on
blogs
and
websites.
</li>
<li>
CCrel
-
for
describing
Creative
Commons
and
other
types
of
licenses.
</li>
<li>
GEO
-
for
describing
geographic
location.
</li>
<li>
VCard
-
for
describing
organizations
and
people.
</li>
<li>
DOAP
-
for
describing
projects.
</li>
</ul>
<p>
A
JSON-LD
Web
Service
could
define
these
as
<em>
prefix
</em>
es
in
their
default
context
beside
the
<em>
terms
</em>
that
are
already
defined.
Using
this
feature,
developers
could
also
<del class="diff-old">do
</del>
<ins class="diff-chg">express
</ins>
markup
like
this:
</p>
<pre class="example">
<del class="diff-old">{"",
 "" : "Manu Sporny",
 ",
"sioc:avatar"
:
"&lt;http://twitter.com/account/profile_image/manusporny&gt;"
</del>
<ins class="diff-chg">{
  "<span class="diff">rdf:type</span>": "<span class="diff">foaf:Person</span>",
  "<span class="diff">foaf:name</span>": "Manu Sporny",
  "<span class="diff">foaf:homepage</span>": "&lt;http://manu.sporny.org/&gt;"<span class="diff">,
  "sioc:avatar": "&lt;http://twitter.com/account/profile_image/manusporny&gt;"</span>
</ins>
}
</pre>
<p>
Developers
<del class="diff-old">could
</del>
<ins class="diff-chg">can
</ins>
also
<del class="diff-old">be
allowed
to
</del>
specify
their
own
Vocabulary
documents
by
modifying
the
default
<del class="diff-old">context,
</del>
<ins class="diff-chg">context
in-line
using
the
</ins><code><ins class="diff-chg">
#
</ins></code><ins class="diff-chg">
character,
</ins>
like
so:
</p>
<pre class="example">
<del class="diff-old">[{"a" : "Context",
   "myvocab" : "http://example.org/myvocab#"}
 },
 {"a" : "foaf:Person",
 "foaf:name" : "Manu Sporny",
 "foaf:homepage" : "&lt;http://manu.sporny.org/&gt;",
 "sioc:avatar" : "&lt;http://twitter.com/account/profile_image/manusporny&gt;",
 "myvocab:credits" : 500}
]
</del>
<ins class="diff-chg">{
</ins>  <span class="diff">"#": { "myvocab": "http://example.org/myvocab#" }</span>,<ins class="diff-chg">
  "a": "foaf:Person",
  "foaf:name": "Manu Sporny",
  "foaf:homepage": "&lt;http://manu.sporny.org/&gt;",
  "sioc:avatar": "&lt;http://twitter.com/account/profile_image/manusporny&gt;"<span class="diff">,
  "myvocab:credits": 500</span>
}
</ins>
</pre>
<p>
<ins class="diff-new">Think
of
the
</ins><code><ins class="diff-new">
#
</ins></code><ins class="diff-new">
character
as
a
"hashtable",
which
maps
one
string
to
another
string.
In
the
example
above,
the
</ins><code><ins class="diff-new">
myvocab
</ins></code><ins class="diff-new">
string
is
replaced
with
"
</ins><code><ins class="diff-new">
http://example.org/myvocab#
</ins></code><ins class="diff-new">
"
when
it
is
detected
above.
In
the
example
above,
"
</ins><code><ins class="diff-new">
myvocab:credits
</ins></code><ins class="diff-new">
"
would
expand
to
"
</ins><code><ins class="diff-new">
http://example.org/myvocab#credits
</ins></code><ins class="diff-new">
".
</ins></p><p>
This
mechanism
is
a
short-hand
for
RDF,
and
if
defined,
will
give
developers
an
unambiguous
way
to
map
any
JSON
value
to
RDF.
</p>
<p>
</p>
</div>
<div id="an-example-of-a-default-context" class="section">
<h2>
<span class="secno">
<del class="diff-old">4.4
</del>
<ins class="diff-chg">6.
</ins>
</span>
An
Example
of
a
Default
Context
</h2>
<p>
<del class="diff-old">To
be
clear,
</del>
<ins class="diff-chg">JSON-LD
strives
to
ensure
that
developers
don't
have
to
change
</ins>
the
<ins class="diff-new">JSON
that
is
going
into
and
being
returned
from
their
Web
applications.
A
</ins>
JSON-LD
aware
Web
Service
<del class="diff-old">could
</del>
<em class="rfc2119" title="may">
<ins class="diff-chg">may
</ins></em>
define
a
default
<del class="diff-old">context
like
</del>
<ins class="diff-chg">context.
For
example,
</ins>
the
<del class="diff-old">following:
</del>
<ins class="diff-chg">following
default
context
could
apply
to
all
incoming
Web
Service
calls
previously
accepting
only
JSON
data:
</ins>
</p>
<pre class="example">
<del class="diff-old">{"a" : "Context",
 "__vocab__" : "http://example.org/default-vocab#",
 "xsd" : "http://www.w3.org/2001/XMLSchema#",
 "dc" : "http://purl.org/dc/terms/",
 "foaf" : "http://xmlns.com/foaf/0.1/",
 "sioc" : "http://rdfs.org/sioc/ns#",
 "cc" : "http://creativecommons.org/ns#",
 "geo" : "http://www.w3.org/2003/01/geo/wgs84_pos#",
 "vcard" : "http://www.w3.org/2006/vcard/ns#",
 "cal" : "http://www.w3.org/2002/12/cal/ical#",
 "doap" : "http://usefulinc.com/ns/doap#",
 "Person" : "http://xmlns.com/foaf/0.1/Person",
 "name" : "http://xmlns.com/foaf/0.1/name",
 "homepage" : "http://xmlns.com/foaf/0.1/homepage"
</del>
<ins class="diff-chg">{
  "#": 
  {
    "__vocab__": "http://example.org/default-vocab#",
    "xsd": "http://www.w3.org/2001/XMLSchema#",
    "dc": "http://purl.org/dc/terms/",
    "foaf": "http://xmlns.com/foaf/0.1/",
    "sioc": "http://rdfs.org/sioc/ns#",
    "cc": "http://creativecommons.org/ns#",
    "geo": "http://www.w3.org/2003/01/geo/wgs84_pos#",
    "vcard": "http://www.w3.org/2006/vcard/ns#",
    "cal": "http://www.w3.org/2002/12/cal/ical#",
    "doap": "http://usefulinc.com/ns/doap#",
    "Person": "http://xmlns.com/foaf/0.1/Person",
    "name": "http://xmlns.com/foaf/0.1/name",
    "homepage": "http://xmlns.com/foaf/0.1/homepage"
  }
</ins>
}
</pre>
<p>
The
<code>
__vocab__
</code>
prefix
is
a
special
prefix
that
states
that
any
term
that
doesn't
resolve
to
a
term
or
a
prefix
should
be
appended
to
the
<code>
__vocab__
</code>
IRI.
This
is
done
to
ensure
that
terms
can
be
transformed
to
an
IRI
at
all
times.
</p>
</div>
<div id="the-json-ld-processing-algorithm" class="section">
<h2>
<span class="secno">
<del class="diff-old">4.5
</del>
<ins class="diff-chg">7.
</ins>
</span>
<del class="diff-old">Markup
Examples
</del>
<ins class="diff-chg">The
JSON-LD
Processing
Algorithm
</ins></h2><p><ins class="diff-chg">
The
processing
algorithm
described
in
this
section
is
provided
in
order
to
demonstrate
how
one
might
implement
a
JSON-LD
processor.
Conformant
implementations
are
only
required
to
produce
the
same
type
and
number
of
triples
during
the
output
process
and
are
not
required
to
implement
the
algorithm
exactly
as
described.
</ins></p>
<p class="issue">
<del class="diff-old">Write
</del>
<ins class="diff-chg">The
Processing
Algorithm
is
a
work
in
progress,
there
are
still
major
bugs
in
the
algorithm
and
it's
difficult
to
follow.
It's
provided
only
to
very
early
implementers
to
give
them
an
idea
of
how
to
implement
a
processor.
</ins></p><h4 id="processing-algorithm-terms"><ins class="diff-chg">
Processing
Algorithm
Terms
</ins></h4><ul><li><dfn title="default_context" id="dfn-default_context"><ins class="diff-chg">
default
context
</ins></dfn><ins class="diff-chg">
-
a
context
that
is
specified
to
the
JSON-LD
processing
algorithm
before
processing
begins.
</ins></li><li><dfn title="default_graph" id="dfn-default_graph"><ins class="diff-chg">
default
graph
</ins></dfn><ins class="diff-chg">
-
the
destination
graph
for
all
triples
generated
by
JSON-LD
markup.
</ins></li><li><dfn title="active_subject" id="dfn-active_subject"><ins class="diff-chg">
active
subject
</ins></dfn><ins class="diff-chg">
-
the
currently
active
subject
that
the
processor
should
use
when
generating
triples.
</ins></li><li><dfn title="inherited_subject" id="dfn-inherited_subject"><ins class="diff-chg">
inherited
subject
</ins></dfn><ins class="diff-chg">
-
a
subject
that
was
detected
at
a
higher
level
of
processing
to
be
used
to
generate
a
triple
once
a
</ins><a class="tref" title="current_subject"><ins class="diff-chg">
current
subject
</ins></a><ins class="diff-chg">
is
discovered
or
generated.
</ins></li><li><dfn title="active_property" id="dfn-active_property"><ins class="diff-chg">
active
property
</ins></dfn><ins class="diff-chg">
-
the
currently
active
property
that
the
processor
should
use
when
generating
triples.
</ins></li><li><dfn title="inherited_property" id="dfn-inherited_property"><ins class="diff-chg">
inherited
property
</ins></dfn><ins class="diff-chg">
-
a
property
that
was
detected
at
a
higher
level
of
processing
to
be
used
to
generate
a
triple
once
a
</ins><a class="tref" title="current_subject"><ins class="diff-chg">
current
subject
</ins></a><ins class="diff-chg">
is
discovered
or
generated.
</ins></li><li><dfn title="active_object" id="dfn-active_object"><ins class="diff-chg">
active
object
</ins></dfn><ins class="diff-chg">
-
the
currently
active
object
that
the
processor
should
use
when
generating
triples.
</ins></li><li><dfn title="active_context" id="dfn-active_context"><ins class="diff-chg">
active
context
</ins></dfn><ins class="diff-chg">
-
a
context
that
is
used
to
resolve
CURIEs
while
the
processing
algorithm
is
running.
The
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
is
the
top-most
item
on
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
stack.
</ins></li><li><dfn title="local_context" id="dfn-local_context"><ins class="diff-chg">
local
context
</ins></dfn><ins class="diff-chg">
-
a
context
that
is
specified
at
the
JSON
associative-array
level,
specified
via
the
</ins><code><ins class="diff-chg">
#
</ins></code><ins class="diff-chg">
key.
</ins></li><li><dfn title="list_of_incomplete_triples" id="dfn-list_of_incomplete_triples"><ins class="diff-chg">
list
of
incomplete
triples
</ins></dfn><ins class="diff-chg">
-
A
list
of
triples
that
have
yet
to
have
their
subject
set.
</ins></li><li><dfn title="list_of_unprocessed_items" id="dfn-list_of_unprocessed_items"><ins class="diff-chg">
list
of
unprocessed
items
</ins></dfn><ins class="diff-chg">
-
A
list
of
objects
that
cannot
be
processed
until
a
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-chg">
local
context
</ins></a><ins class="diff-chg">
is
detected
or
the
end
of
the
current
associative-array
is
detected.
</ins></li><li><dfn title="processor_state" id="dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></dfn><ins class="diff-chg">
-
the
processor
state,
which
includes
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
stack,
</ins><a class="tref" title="current_subject"><ins class="diff-chg">
current
subject
</ins></a>,<a class="tref" title="current_property"><ins class="diff-chg">
current
property
</ins></a>,<a class="tref internalDFN" title="list_of_incomplete_triples" href="#dfn-list_of_incomplete_triples"><ins class="diff-chg">
list
of
incomplete
triples
</ins></a>,<ins class="diff-chg">
and
the
</ins><a class="tref internalDFN" title="list_of_unprocessed_items" href="#dfn-list_of_unprocessed_items"><ins class="diff-chg">
list
of
unprocessed
items
</ins></a>.</li></ul><p><ins class="diff-chg">
The
algorithm
below
is
designed
for
streaming
(SAX-based)
implementations.
Implementers
will
find
that
non-streaming
(document-based)
implementations
will
be
much
easier
to
implement
as
full
access
to
the
JSON
object
model
eliminates
</ins>
some
<del class="diff-old">introductory
stuff
about
</del>
<ins class="diff-chg">of
the
steps
that
are
necessary
for
streaming
implementations.
A
conforming
JSON-LD
processor
</ins><em class="rfc2119" title="must"><ins class="diff-chg">
must
</ins></em><ins class="diff-chg">
implement
a
processing
algorithm
that
results
in
the
same
</ins><a class="tref internalDFN" title="default_graph" href="#dfn-default_graph"><ins class="diff-chg">
default
graph
</ins></a><ins class="diff-chg">
that
the
following
algorithm
generates:
</ins></p><ol class="algorithm"><li id="processing-step-default-context"><ins class="diff-chg">
If
a
</ins><a class="tref internalDFN" title="default_context" href="#dfn-default_context"><ins class="diff-chg">
default
context
</ins></a><ins class="diff-chg">
is
supplied
to
the
processing
algorithm,
push
it
onto
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
stack.
</ins></li><li id="processing-step-associative"><ins class="diff-chg">
If
an
associative
array
is
detected,
create
a
new
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a>.<ins class="diff-chg">
Copy
the
</ins><a class="tref" title="current_context"><ins class="diff-chg">
current
context
</ins></a><ins class="diff-chg">
stack
to
the
newly
created
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a>.<ins class="diff-chg">
Push
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
onto
the
newly
created
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-chg">
processor
state
</ins></a><ins class="diff-chg">
's
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-chg">
active
context
</ins></a><ins class="diff-chg">
stack.
For
each
key-value
pair
in
</ins>
the
<ins class="diff-new">associative
array,
using
the
newly
created
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-new">
processor
state
</ins></a><ins class="diff-new">
do
the
following:
</ins><ol class="algorithm"><li><ins class="diff-new">
If
a
</ins><code><ins class="diff-new">
#
</ins></code><ins class="diff-new">
key
is
found,
the
processor
merges
each
key-value
pair
in
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-new">
local
context
</ins></a><ins class="diff-new">
into
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-new">
active
context
</ins></a>,<ins class="diff-new">
overwriting
any
duplicate
values
in
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-new">
active
context
</ins></a>.<ins class="diff-new">
Process
each
object
in
the
</ins><a class="tref internalDFN" title="list_of_unprocessed_items" href="#dfn-list_of_unprocessed_items"><ins class="diff-new">
list
of
unprocessed
items
</ins></a>,<ins class="diff-new">
starting
at
</ins><a href="#processing-subject"><ins class="diff-new">
Step
2.2
</ins></a>.</li><li id="processing-associative"><ins class="diff-new">
If
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-new">
local
context
</ins></a><ins class="diff-new">
has
not
been
detected,
the
current
key-value
pair
is
placed
into
the
</ins><a class="tref internalDFN" title="list_of_unprocessed_items" href="#dfn-list_of_unprocessed_items"><ins class="diff-new">
list
of
unprocessed
items
</ins></a><ins class="diff-new">
and
processing
proceeds
to
the
next
key-value
pair.
Otherwise,
if
the
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-new">
local
context
</ins></a><ins class="diff-new">
is
known
perform
the
following
steps:
</ins></li><ol class="algorithm"><li id="processing-subject"><ins class="diff-new">
If
a
</ins><code><ins class="diff-new">
@
</ins></code><ins class="diff-new">
key
is
found,
the
processor
sets
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a><ins class="diff-new">
to
the
value
after
</ins><a href="#markup-of-rdf-concepts"><ins class="diff-new">
Object
Processing
</ins></a><ins class="diff-new">
has
been
performed.
</ins><ol class="algorithm"><li><ins class="diff-new">
If
the
</ins><a class="tref internalDFN" title="inherited_subject" href="#dfn-inherited_subject"><ins class="diff-new">
inherited
subject
</ins></a><ins class="diff-new">
and
</ins><a class="tref internalDFN" title="inherited_property" href="#dfn-inherited_property"><ins class="diff-new">
inherited
property
</ins></a><ins class="diff-new">
values
are
specified,
generate
a
triple
using
the
</ins><a class="tref internalDFN" title="inherited_subject" href="#dfn-inherited_subject"><ins class="diff-new">
inherited
subject
</ins></a><ins class="diff-new">
for
the
subject,
the
</ins><a class="tref internalDFN" title="inherited_property" href="#dfn-inherited_property"><ins class="diff-new">
inherited
property
</ins></a><ins class="diff-new">
for
the
property,
and
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a><ins class="diff-new">
for
the
object.
</ins></li><li><ins class="diff-new">
If
there
are
any
triples
in
the
</ins><a class="tref internalDFN" title="list_of_incomplete_triples" href="#dfn-list_of_incomplete_triples"><ins class="diff-new">
list
of
incomplete
triples
</ins></a>,<ins class="diff-new">
complete
each
triple
using
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a><ins class="diff-new">
as
the
subject
for
each
triple.
</ins></li></ol></li><li><ins class="diff-new">
If
an
</ins><code><ins class="diff-new">
a
</ins></code><ins class="diff-new">
key
is
found,
set
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a><ins class="diff-new">
to
</ins><code><ins class="diff-new">
http://www.w3.org/1999/02/22-rdf-syntax-ns#type
</ins></code>.</li><li><ins class="diff-new">
If
a
key
that
is
not
</ins><code><ins class="diff-new">
#
</ins></code>,<code><ins class="diff-new">
@
</ins></code>,<ins class="diff-new">
or
</ins><code><ins class="diff-new">
a
</ins></code><ins class="diff-new">
is
found,
set
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a><ins class="diff-new">
by
performing
</ins><a href="#markup-of-rdf-concepts"><ins class="diff-new">
Property
Processing
</ins></a><ins class="diff-new">
on
the
key.
</ins></li><li><ins class="diff-new">
If
the
value
is
not
an
array,
set
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-new">
active
object
</ins></a><ins class="diff-new">
by
performing
</ins><a href="#markup-of-rdf-concepts"><ins class="diff-new">
Object
Processing
</ins></a><ins class="diff-new">
on
the
value.
Generate
a
triple
representing
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a>,<ins class="diff-new">
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a><ins class="diff-new">
and
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-new">
active
object
</ins></a>.</li><li><ins class="diff-new">
If
the
value
is
an
associative
array,
then
process
the
value
starting
at
</ins><a href="#processing-step-associative"><ins class="diff-new">
Step
2
</ins></a>.</li><li><ins class="diff-new">
If
the
value
is
a
regular
array,
then
process
the
value
starting
at
</ins><a href="#processing-step-array"><ins class="diff-new">
Step
3
</ins></a><ins class="diff-new">
ensuring
that
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a><ins class="diff-new">
and
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a><ins class="diff-new">
are
copied
to
a
newly
created
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-new">
processor
state
</ins></a>.</li><li><ins class="diff-new">
If
the
end
of
the
associative
array
is
detected,
and
a
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a><ins class="diff-new">
was
not
discovered,
then:
</ins><ol class="algorithm"><li><ins class="diff-new">
Generate
a
</ins><a class="tref" title="blank_node_identifier"><ins class="diff-new">
blank
node
identifier
</ins></a><ins class="diff-new">
and
set
it
as
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a>.</li><li><ins class="diff-new">
Complete
any
previously
incomplete
triples
by
running
all
substeps
of
</ins><a href="#processing-subject"><ins class="diff-new">
Step
2.2.1
</ins></a>.</li></ol></li><li><ins class="diff-new">
If
the
end
of
the
associative
array
is
detected,
and
a
</ins><a class="tref internalDFN" title="local_context" href="#dfn-local_context"><ins class="diff-new">
local
context
</ins></a><ins class="diff-new">
was
not
discovered,
then
assume
that
the
</ins><a class="tref internalDFN" title="active_context" href="#dfn-active_context"><ins class="diff-new">
active
context
</ins></a><ins class="diff-new">
is
unmodified
and
run
all
substeps
of
</ins><a href="#processing-associative"><ins class="diff-new">
Step
2.2
</ins></a><ins class="diff-new">
on
the
</ins><a class="tref internalDFN" title="list_of_unprocessed_items" href="#dfn-list_of_unprocessed_items"><ins class="diff-new">
list
of
unprocessed
items
</ins></a>.</li></ol></ol></li><li id="processing-step-array"><ins class="diff-new">
If
a
regular
array
is
detected,
process
each
value
in
the
array
by
doing
the
following:
</ins><ol class="algorithm"><li><ins class="diff-new">
If
the
value
is
an
associative
array,
processes
per
</ins><a href="#processing-step-associative"><ins class="diff-new">
Step
2
</ins></a>,<ins class="diff-new">
ensuring
to
set
the
</ins><a class="tref internalDFN" title="inherited_subject" href="#dfn-inherited_subject"><ins class="diff-new">
inherited
subject
</ins></a><ins class="diff-new">
to
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a><ins class="diff-new">
and
the
</ins><a class="tref internalDFN" title="inherited_property" href="#dfn-inherited_property"><ins class="diff-new">
inherited
property
</ins></a><ins class="diff-new">
to
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a><ins class="diff-new">
in
the
newly
created
</ins><a class="tref internalDFN" title="processor_state" href="#dfn-processor_state"><ins class="diff-new">
processor
state
</ins></a>.</li><li><ins class="diff-new">
If
the
value
is
not
an
array,
set
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-new">
active
object
</ins></a><ins class="diff-new">
by
performing
</ins><a href="#markup-of-rdf-concepts"><ins class="diff-new">
Object
Processing
</ins></a><ins class="diff-new">
on
the
value.
Generate
a
triple
representing
the
</ins><a class="tref internalDFN" title="active_subject" href="#dfn-active_subject"><ins class="diff-new">
active
subject
</ins></a>,<ins class="diff-new">
the
</ins><a class="tref internalDFN" title="active_property" href="#dfn-active_property"><ins class="diff-new">
active
property
</ins></a><ins class="diff-new">
and
the
</ins><a class="tref internalDFN" title="active_object" href="#dfn-active_object"><ins class="diff-new">
active
object
</ins></a><ins class="diff-new">
and
place
it
into
the
</ins><a class="tref internalDFN" title="default_graph" href="#dfn-default_graph"><ins class="diff-new">
default
graph
</ins></a>.</li><li><ins class="diff-new">
If
the
value
is
a
regular
array,
should
we
support
RDF
List/Sequence
Processing?
</ins><div class="issue"><ins class="diff-new">
If
the
value
is
a
regular
array,
should
we
support
RDF
List/Sequence
generation
of
triples?
For
example,
would
implementing
this
be
worth
the
more
complex
processing
rules:
"ex:orderedItems"
:
[["one",
"two",
"three"]]
</ins></div></li></ol></li></ol></div><div id="markup-examples" class="section"><h2><span class="secno"><ins class="diff-new">
8.
</ins></span>
Markup
<del class="diff-old">Examples.
</del>
<ins class="diff-chg">Examples
</ins></h2><p><ins class="diff-chg">
The
JSON-LD
markup
examples
below
demonstrate
how
JSON-LD
can
be
used
to
express
semantic
data
marked
up
in
other
languages
such
as
RDFa,
Microformats,
and
Microdata.
These
sections
are
merely
provided
as
proof
that
JSON-LD
is
very
flexible
in
what
it
can
express
across
different
Linked
Data
approaches.
</ins>
</p>
<div id="rdfa" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.5.1
</del>
<ins class="diff-chg">8.1
</ins>
</span>
RDFa
</h3>
<p>
<ins class="diff-chg">The
following
example
describes
three
people
with
their
respective
names
and
homepages.
</ins></p>
<pre class="example">
&lt;div <span class="diff">prefix="foaf: http://xmlns.com/foaf/0.1/"</span>&gt;
   &lt;ul&gt;
      &lt;li <span class="diff">typeof="foaf:Person"</span>&gt;
        &lt;a <span class="diff">rel="foaf:homepage" href="http://example.com/bob/" property="foaf:name" </span>&gt;Bob&lt;/a&gt;
      &lt;/li&gt;
      &lt;li <span class="diff">typeof="foaf:Person"</span>&gt;
        &lt;a <span class="diff">rel="foaf:homepage" href="http://example.com/eve/" property="foaf:name" </span>&gt;Eve&lt;/a&gt;
      &lt;/li&gt;
      &lt;li <span class="diff">typeof="foaf:Person"</span>&gt;
        &lt;a <span class="diff">rel="foaf:homepage" href="http://example.com/manu/" property="foaf:name" </span>&gt;Manu&lt;/a&gt;
      &lt;/li&gt;
   &lt;/ul&gt;
&lt;/div&gt;
</pre>
<p>
<del class="diff-old">Representation:
</del>
<ins class="diff-chg">An
example
JSON-LD
implementation
is
described
below,
however,
there
are
other
ways
to
mark-up
this
information
such
that
the
context
is
not
repeated.
</ins>
</p>
<pre class="example">
<del class="diff-old">[{ 
   "a" : "Context",
   "foaf" : "http://xmlns.com/foaf/0.1/"
 },
</del>
<ins class="diff-chg">[
</ins>
 {
<del class="diff-old">    "@" : "_:bnode1",
    "a" : "foaf:Person",
    "foaf:homepage" : "&lt;http://example.com/bob/&gt;",
    "foaf:name" : "Bob"
</del>
<ins class="diff-chg">   "#": { "foaf": "http://xmlns.com/foaf/0.1/" },
   "@": "_:bnode1",
   "a": "foaf:Person",
   "foaf:homepage": "&lt;http://example.com/bob/&gt;",
   "foaf:name": "Bob"
</ins>
 },
 {
<del class="diff-old">    "@" : "_:bnode2",
    "a" : "foaf:Person",
    "foaf:homepage" : "&lt;http://example.com/eve/&gt;",
    "foaf:name" : "Eve"
</del>
<ins class="diff-chg">   "#": { "foaf": "http://xmlns.com/foaf/0.1/" },
   "@": "_:bnode2",
   "a": "foaf:Person",
   "foaf:homepage": "&lt;http://example.com/eve/&gt;",
   "foaf:name": "Eve"
</ins>
 },
 {
<del class="diff-old">    "@" : "_:bnode2",
    "a" : "foaf:Person",
    "foaf:homepage" : "&lt;http://example.com/manu/&gt;",
    "foaf:name" : "Manu"
</del>
<ins class="diff-chg">   "#": { "foaf": "http://xmlns.com/foaf/0.1/" },
   "@": "_:bnode3",
   "a": "foaf:Person",
   "foaf:homepage": "&lt;http://example.com/manu/&gt;",
   "foaf:name": "Manu"
</ins>
 }
]
</pre>
</div>
<div id="microformats" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.5.2
</del>
<ins class="diff-chg">8.2
</ins>
</span>
Microformats
</h3>
<p>
<ins class="diff-chg">The
following
example
uses
a
simple
Microformats
hCard
example
to
express
how
the
Microformat
is
represented
in
JSON-LD.
</ins></p>
<pre class="example">
&lt;div class="vcard"&gt;
 &lt;a class="url fn" href="http://tantek.com/"&gt;Tantek Çelik&lt;/a&gt;
&lt;/div&gt;
</pre>
<p>
<del class="diff-old">Representation:
</del>
<ins class="diff-chg">The
representation
of
the
hCard
expresses
the
Microformat
terms
in
the
context
and
uses
them
directly
for
the
</ins><code><ins class="diff-chg">
url
</ins></code><ins class="diff-chg">
and
</ins><code><ins class="diff-chg">
fn
</ins></code><ins class="diff-chg">
properties.
Also
note
that
the
Microformat
to
JSON-LD
processor
has
generated
the
proper
URL
type
for
</ins><code><ins class="diff-chg">
http://tantek.com
</ins></code>.
</p>
<pre class="example">
<del class="diff-old">[{ 
   "a" : "Context",
   "vcard" : "http://microformats.org/profile/hcard#vcard"
   "url" : "http://microformats.org/profile/hcard#url"
   "fn" : "http://microformats.org/profile/hcard#fn"
 },
 {
    "@" : "_:bnode1",
    "a" : "vcard",
    "url" : "&lt;http://tantek.com/&gt;",
    "fn" : "Tantek Çelik"
 }
]
</del>
<ins class="diff-chg">{
  "#": 
  {
    "vcard": "http://microformats.org/profile/hcard#vcard"
    "url": "http://microformats.org/profile/hcard#url"
    "fn": "http://microformats.org/profile/hcard#fn"
  },
  "@": "_:bnode1",
  "a": "vcard",
  "url": "&lt;http://tantek.com/&gt;",
  "fn": "Tantek Çelik"
}
</ins>
</pre>
</div>
<div id="microdata" class="section">
<h3>
<span class="secno">
<del class="diff-old">4.5.3
</del>
<ins class="diff-chg">8.3
</ins>
</span>
Microdata
</h3>
<p>
<ins class="diff-chg">The
Microdata
example
below
expresses
book
information
as
a
Microdata
Work
item.
</ins></p>
<pre class="example">
&lt;dl itemscope
    itemtype="http://purl.org/vocab/frbr/core#Work"
    itemid="http://purl.oreilly.com/works/45U8QJGZSQKDH8N"&gt;
 &lt;dt&gt;Title&lt;/dt&gt;
 &lt;dd&gt;&lt;cite itemprop="http://purl.org/dc/terms/title"&gt;Just a Geek&lt;/cite&gt;&lt;/dd&gt;
 &lt;dt&gt;By&lt;/dt&gt;
 &lt;dd&gt;&lt;span itemprop="http://purl.org/dc/terms/creator"&gt;Wil Wheaton&lt;/span&gt;&lt;/dd&gt;
 &lt;dt&gt;Format&lt;/dt&gt;
 &lt;dd itemprop="http://purl.org/vocab/frbr/core#realization"
     itemscope
     itemtype="http://purl.org/vocab/frbr/core#Expression"
     itemid="http://purl.oreilly.com/products/9780596007683.BOOK"&gt;
  &lt;link itemprop="http://purl.org/dc/terms/type" href="http://purl.oreilly.com/product-types/BOOK"&gt;
  Print
 &lt;/dd&gt;
 &lt;dd itemprop="http://purl.org/vocab/frbr/core#realization"
     itemscope
     itemtype="http://purl.org/vocab/frbr/core#Expression"
     itemid="http://purl.oreilly.com/products/9780596802189.EBOOK"&gt;
  &lt;link itemprop="http://purl.org/dc/terms/type" href="http://purl.oreilly.com/product-types/EBOOK"&gt;
  Ebook
 &lt;/dd&gt;
&lt;/dl&gt;
</pre>
<p>
<del class="diff-old">Representation:
</del>
<ins class="diff-chg">Note
that
the
JSON-LD
representation
of
the
Microdata
information
stays
true
to
the
desires
of
the
Microdata
community
to
avoid
contexts
and
instead
refer
to
items
by
their
full
IRI.
</ins>
</p>
<pre class="example">
<del class="diff-old">[{ 
   "a" : "Context",
   "__vocab__" : "http://www.w3.org/1999/xhtml/microdata#",
   "frbr" : "http://purl.org/vocab/frbr/core#",
   "dc" : "http://purl.org/dc/terms/"
 },
 {
    "a" : "frbr:Work",
    "@" : "&lt;http://purl.oreilly.com/works/45U8QJGZSQKDH8N&gt;",
    "dc:title" : "Just a Geek",
    "dc:creator" : "Whil Wheaton",
    "frbr:realization" : ["&lt;http://purl.oreilly.com/products/9780596007683.BOOK&gt;", "&lt;http://purl.oreilly.com/products/9780596802189.EBOOK&gt;"]
 },
 {
    "a" : "frbr:Expression",
    "@" : "&lt;http://purl.oreilly.com/products/9780596007683.BOOK&gt;",
    "dc:type" : "&lt;http://purl.oreilly.com/product-types/BOOK&gt;"
 },
 {
    "a" : "frbr:Expression",
    "@" : "&lt;http://purl.oreilly.com/products/9780596802189.EBOOK&gt;",
    "dc:type" : "&lt;http://purl.oreilly.com/product-types/EBOOK&gt;"
 }
</del>
<ins class="diff-chg">[
  {
    "@": "&lt;http://purl.oreilly.com/works/45U8QJGZSQKDH8N&gt;",
    "a": "http://purl.org/vocab/frbr/core#Work",
    "http://purl.org/dc/terms/title": "Just a Geek",
    "http://purl.org/dc/terms/creator": "Whil Wheaton",
    "http://purl.org/vocab/frbr/core#realization": 
      ["&lt;http://purl.oreilly.com/products/9780596007683.BOOK&gt;", "&lt;http://purl.oreilly.com/products/9780596802189.EBOOK&gt;"]
  },
  {
    "@": "&lt;http://purl.oreilly.com/products/9780596007683.BOOK&gt;",
    "a": "&lt;http://purl.org/vocab/frbr/core#Expression&gt;",
    "http://purl.org/dc/terms/type": "&lt;http://purl.oreilly.com/product-types/BOOK&gt;"
  },
  {
    "@": "&lt;http://purl.oreilly.com/products/9780596802189.EBOOK&gt;",
    "a": "http://purl.org/vocab/frbr/core#Expression",
    "http://purl.org/dc/terms/type": "&lt;http://purl.oreilly.com/product-types/EBOOK&gt;"
  }
</ins>
]
</pre>
</div>
</div>
<div id="markup-of-rdf-concepts" class="section">
<h2>
<span class="secno">
<del class="diff-old">5.
</del>
<ins class="diff-chg">9.
</ins>
</span>
Markup
of
RDF
Concepts
</h2>
<del class="diff-old">Need
</del>
<p>
<ins class="diff-chg">JSON-LD
is
designed
</ins>
to
<del class="diff-old">write
introduction
</del>
<ins class="diff-chg">ensure
that
most
Linked
Data
concepts
can
be
marked
up
in
a
way
that
is
simple
</ins>
to
<ins class="diff-new">understand
and
author
by
Web
developers.
In
many
cases,
Javascript
objects
can
become
Linked
Data
with
the
simple
addition
of
a
context.
Since
</ins>
RDF
<del class="diff-old">Concepts
</del>
<ins class="diff-chg">is
also
an
important
sub-community
of
the
Linked
Data
movement,
it
is
important
that
all
RDF
concepts
are
well-represented
in
this
specification.
This
</ins>
section
<ins class="diff-new">details
how
each
RDF
concept
can
be
expressed
in
JSON-LD.
</ins>
</p>
<div id="iris" class="section">
<h3>
<span class="secno">
<del class="diff-old">5.1
</del>
<ins class="diff-chg">9.1
</ins>
</span>
IRIs
</h3>
<p>
<ins class="diff-new">Expressing
IRIs
are
fundamental
to
Linked
Data
as
that
is
how
most
subjects
and
many
objects
are
identified.
IRIs
can
be
expressed
by
wrapping
a
text
string
with
the
</ins><code><</code> and <code><ins class="diff-new">
>
</ins></code><ins class="diff-new">
characters.
</ins></p>
<pre class="example">
{
...
<del class="diff-old"> "foaf:homepage" : "",
</del>
<ins class="diff-chg">  "foaf:homepage": "<span class="diff">&lt;</span>http://manu.sporny.org<span class="diff">&gt;</span>",
</ins>
...
}
</pre>
<p>
<ins class="diff-new">The
example
above
would
set
the
object
to
an
IRI
with
the
value
of
</ins><code><ins class="diff-new">
http://manu.sporny.org
</ins></code>.</p><p><ins class="diff-new">
Wrapping
IRIs
with
the
</ins><code><</code> and <code><ins class="diff-new">
>
</ins></code><ins class="diff-new">
characters
are
only
necessary
when
IRIs
are
specified
as
objects.
At
no
other
point
do
you
need
to
wrap
an
IRI.
You
do
not
need
to
wrap
IRIs
when
declaring
a
property,
declaring
a
CURIE,
or
describing
key-value
pairs
in
a
context.
</ins></p>
</div>
<div id="identifying-the-subject" class="section">
<h3>
<span class="secno">
<del class="diff-old">5.2
</del>
<ins class="diff-chg">9.2
</ins>
</span>
Identifying
the
Subject
</h3>
<p>
<ins class="diff-new">A
subject
is
declared
using
the
</ins><code><ins class="diff-new">
@
</ins></code><ins class="diff-new">
key.
The
subject
is
the
first
piece
of
information
needed
by
the
JSON-LD
processor
in
order
to
create
the
(subject,
predicate,
object)
tuple,
also
known
as
a
triple.
</ins></p>
<pre class="example">
{
...
<del class="diff-old"> "",
</del>
<ins class="diff-chg">  "<span class="diff">@</span>": "<span class="diff">&lt;http://example.org/people#joebob&gt;</span>",
</ins>
...
}
</pre>
<p>
<ins class="diff-new">The
example
above
would
set
the
subject
to
</ins><code><http://example.org/people#joebob></code>.</p>
</div>
<div id="specifying-the-type" class="section">
<h3>
<span class="secno">
<del class="diff-old">5.3
</del>
<ins class="diff-chg">9.3
</ins>
</span>
Specifying
the
Type
</h3>
<p>
<ins class="diff-new">The
type
of
a
particular
subject
can
be
specified
using
the
</ins><code><ins class="diff-new">
a
</ins></code><ins class="diff-new">
key.
Specifying
the
type
in
this
way
will
generate
a
triple
of
the
form
(subject,
type,
type-url).
</ins></p>
<pre class="example">
{
...
<del class="diff-old"> "",
</del>
<ins class="diff-chg">  "@": "&lt;http://example.org/people#joebob&gt;",
  "<span class="diff">a</span>": "<span class="diff">&lt;http://xmlns.com/foaf/0.1/Person&gt;</span>",
</ins>
...
}
</pre>
<p>
<ins class="diff-new">The
example
above
would
generate
the
following
triple
(in
N-Triples
notation):
</ins></p><pre class="example"><ins class="diff-new">
&lt;http://example.org/people#joebob&gt; 
   &lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&gt;
&lt;http://xmlns.com/foaf/0.1/Person&gt;
.
</ins></pre>
</div>
<div id="plain-literals" class="section">
<h3>
<span class="secno">
<del class="diff-old">5.4
</del>
<ins class="diff-chg">9.4
</ins>
</span>
Plain
Literals
</h3>
<p>
<ins class="diff-new">Regular
text
strings
are
called
"plain
literals"
in
RDF
and
are
easily
expressed
using
regular
JSON
strings.
</ins></p>
<pre class="example">
{
...
<del class="diff-old"> "foaf:name" : "",
</del>
<ins class="diff-chg">  "foaf:name": "<span class="diff">Mark Birbeck</span>",
</ins>
...
}
</pre>
</div>
<div id="language-specification-in-plain-literals" class="section">
<h3>
<span class="secno">
<del class="diff-old">5.5
</del>
<ins class="diff-chg">9.5
</ins>
</span>
Language
Specification
in
Plain
Literals
</h3>
<p>
<ins class="diff-new">JSON-LD
attempts
to
make
sure
that
it
is
easy
to
express
triples
in
other
languages
while
simultaneously
ensuring
that
hefty
data
structures
aren't
required
to
accomplish
simple
language
markup.
When
the
</ins><code><ins class="diff-new">
@
</ins></code><ins class="diff-new">
symbol
is
used
in
a
literal,
the
JSON-LD
processor
tags
the
literal
text
with
the
language
tag
that
follows
the
</ins><code><ins class="diff-new">
@
</ins></code><ins class="diff-new">
symbol.
</ins></p>
<pre class="example">
{
...
<del class="diff-old"> "foaf:name" : "",
</del>
<ins class="diff-chg">  "foaf:name": "<span class="diff">花澄@ja</span>",
</ins>
...
}
</pre>
<p>
<ins class="diff-new">The
example
above
would
generate
a
plain
literal
for
</ins><em><ins class="diff-new">
花澄
</ins></em><ins class="diff-new">
and
associate
the
</ins><code><ins class="diff-new">
ja
</ins></code><ins class="diff-new">
language
tag
with
the
triple
that
is
generated.
Languages
</ins><em class="rfc2119" title="must"><ins class="diff-new">
must
</ins></em><ins class="diff-new">
be
expressed
in
[
</ins><cite><a class="bibref" rel="biblioentry" href="#bib-BCP47"><ins class="diff-new">
BCP47
</ins></a></cite><ins class="diff-new">
]
format.
</ins></p>
</div>
<div id="typed-literals" class="section">
<h3>
<span class="secno">
<del class="diff-old">5.6
</del>
<ins class="diff-chg">9.6
</ins>
</span>
Typed
Literals
</h3>
<p>
<ins class="diff-new">Literals
may
also
be
typed
in
JSON-LD
by
using
the
</ins><code><ins class="diff-new">
^^
</ins></code><ins class="diff-new">
sequence
at
the
end
of
the
text
string.
</ins></p>
<pre class="example">
{
...
<del class="diff-old"> "dc:modified" : "",
</del>
<ins class="diff-chg">  "dc:modified": "<span class="diff">2010-05-29T14:17:39+02:00^^xsd:dateTime</span>",
</ins>
...
}
</pre>
<p>
<ins class="diff-new">The
example
above
would
generate
an
object
with
the
value
of
</ins><code><ins class="diff-new">
2010-05-29T14:17:39+02:00
</ins></code><ins class="diff-new">
and
the
datatype
of
</ins><code><ins class="diff-new">
http://www.w3.org/2001/XMLSchema#dateTime
</ins></code>.</p>
</div>
<div id="multiple-objects-for-a-single-property" class="section">
<h3>
<span class="secno">
<del class="diff-old">5.7
</del>
<ins class="diff-chg">9.7
</ins>
</span>
Multiple
Objects
for
a
Single
Property
</h3>
<p>
<ins class="diff-new">A
JSON-LD
author
can
express
multiple
triples
in
a
compact
way
by
using
arrays.
If
a
subject
has
multiple
values
for
the
same
property,
the
author
</ins><em class="rfc2119" title="may"><ins class="diff-new">
may
</ins></em><ins class="diff-new">
express
each
property
as
an
array.
</ins></p>
<pre class="example">
{
...
<del class="diff-old"> "foaf:nick" : ,
</del>
<ins class="diff-chg">  "@": "&lt;http://example.org/people#joebob&gt;",
  "foaf:nick": <span class="diff">["stu", "groknar", "radface"]</span>,
</ins>
...
}
</pre>
<p>
<ins class="diff-new">The
markup
shown
above
would
generate
the
following
triples:
</ins></p><pre class="example"><ins class="diff-new">
&lt;http://example.org/people#joebob&gt; 
   &lt;http://xmlns.com/foaf/0.1/&gt;
      "stu" .
&lt;http://example.org/people#joebob&gt; 
   &lt;http://xmlns.com/foaf/0.1/&gt;
      "groknar" .
&lt;http://example.org/people#joebob&gt; 
   &lt;http://xmlns.com/foaf/0.1/&gt;
"radface"
.
</ins></pre>
</div>
<div id="multiple-typed-literals-for-a-single-property" class="section">
<h3>
<span class="secno">
<del class="diff-old">5.8
</del>
<ins class="diff-chg">9.8
</ins>
</span>
Multiple
Typed
Literals
for
a
Single
Property
</h3>
<p>
<ins class="diff-new">Multiple
typed
literals
are
expressed
very
much
in
the
same
way
as
multiple
properties:
</ins></p>
<pre class="example">
{
...
<del class="diff-old"> "dc:modified" : ],
</del>
<ins class="diff-chg">  "@": "&lt;http://example.org/articles/8&gt;",
  "dcterms:modified": <span class="diff">["2010-05-29T14:17:39+02:00^^xsd:dateTime", "2010-05-30T09:21:28-04:00^^xsd:dateTime"</span>],
</ins>
...
}
</pre>
<p>
<ins class="diff-new">The
markup
shown
above
would
generate
the
following
triples:
</ins></p><pre class="example"><ins class="diff-new">
&lt;http://example.org/articles/8&gt; 
   &lt;http://purl.org/dc/terms/modified&gt;
      "2010-05-29T14:17:39+02:00"^^http://www.w3.org/2001/XMLSchema#dateTime .
&lt;http://example.org/articles/8&gt; 
   &lt;http://purl.org/dc/terms/modified&gt;
"2010-05-30T09:21:28-04:00"^^http://www.w3.org/2001/XMLSchema#dateTime
.
</ins></pre>
</div>
<div id="blank-nodes" class="section">
<h3>
<span class="secno">
<del class="diff-old">5.9
</del>
<ins class="diff-chg">9.9
</ins>
</span>
Blank
Nodes
</h3>
<p>
<ins class="diff-new">At
times,
it
becomes
necessary
to
be
able
to
express
information
without
being
able
to
specify
the
subject.
Typically,
this
is
where
blank
nodes
come
into
play.
In
JSON-LD,
blank
node
identifiers
are
automatically
created
if
a
subject
is
not
specified
using
the
</ins><code><ins class="diff-new">
@
</ins></code><ins class="diff-new">
key.
However,
authors
may
name
blank
nodes
by
using
the
special
</ins><code><ins class="diff-new">
_
</ins></code><ins class="diff-new">
CURIE
prefix.
</ins></p>
<pre class="example">
{
...
<del class="diff-old"> "@" : "",
</del>
<ins class="diff-chg">  "@": "<span class="diff">_:foo</span>",
</ins>
...
}
</pre>
<p>
<ins class="diff-new">The
example
above
would
set
the
subject
to
</ins><code><ins class="diff-new">
_:foo
</ins></code>,<ins class="diff-new">
which
can
then
be
used
later
on
in
the
JSON-LD
markup
to
refer
back
to
the
named
blank
node.
</ins></p>
</div>
<div id="escape-character" class="section">
<h3>
<span class="secno">
<del class="diff-old">5.10
</del>
<ins class="diff-chg">9.10
</ins>
</span>
Escape
Character
</h3>
<p>
Special
characters
in
property
values
<em class="rfc2119" title="must">
must
</em>
be
escaped
in
order
to
not
be
interpreted
as
<ins class="diff-new">CURIEs,
</ins>
IRIs,
language
tags,
or
TypedLiterals.
</p>
<p>
The
special
characters
in
JSON-LD
are:
<code>
<
</code>, <code>
>
</code>,
<code>
@
</code>,
<code>
<ins class="diff-new">#
</ins></code>,<code>:
</code>
and
<code>
^
</code>.
</p>
<pre class="example">
{
...
<del class="diff-old"> "example:code" : ,
</del>
<ins class="diff-chg">  "example:code": <span class="diff">"\\&lt;foobar\\^\\^2\\&gt;"</span>,
</ins>
...
}
</pre>
</div>
<div id="automatic-typing" class="section">
<h3>
<span class="secno">
<del class="diff-old">5.11
</del>
<ins class="diff-chg">9.11
</ins>
</span>
Automatic
Typing
</h3>
<p>
<ins class="diff-new">Since
JSON
is
capable
of
expressing
typed
information
such
as
decimals,
integers
and
boolean
values,
JSON-LD
utilizes
that
information
to
create
</ins><a href="#typed-literals"><ins class="diff-new">
Typed
Literals
</ins></a>.</p>
<pre class="example">
{
...
<del class="diff-old"> // This value is automatically converted to having a type of xsd:decimal
 "measure:cups" : ,
 // This value is automatically converted to having a type of xsd:integer
 "chem:protons" : ,
 // This value is automatically converted to having a type of xsd:boolean
 "sensor:active" : ,
</del>
<ins class="diff-chg">  // This value is automatically converted to having a type of xsd:decimal
  "measure:cups": <span class="diff">5.3</span>,
  // This value is automatically converted to having a type of xsd:integer
  "chem:protons": <span class="diff">12</span>,
  // This value is automatically converted to having a type of xsd:boolean
  "sensor:active": <span class="diff">true</span>,
</ins>
...
}
</pre>
</div>
</div>
<div id="advanced-concepts" class="section">
<h2>
<span class="secno">
<del class="diff-old">A.
</del>
<ins class="diff-chg">10.
</ins>
</span>
<del class="diff-old">Acknowledgements
</del>
<ins class="diff-chg">Advanced
Concepts
</ins>
</h2>
<p class="issue">
<ins class="diff-new">There
are
a
few
advanced
concepts
where
it
is
not
clear
whether
or
not
the
JSON-LD
specification
is
going
to
support
the
complexity
necessary
to
support
each
concept.
The
entire
section
on
Advanced
Concepts
should
be
taken
with
a
grain
of
salt;
it
is
merely
a
list
of
possibilities
where
all
of
the
benefits
and
drawbacks
have
not
been
explored.
</ins></p><div id="disjoint-graphs" class="section"><h3><span class="secno"><ins class="diff-new">
10.1
</ins></span><ins class="diff-new">
Disjoint
Graphs
</ins></h3><p><ins class="diff-new">
When
serializing
an
RDF
graph
that
contains
two
or
more
sections
of
the
graph
which
are
entirely
disjoint,
one
must
use
an
array
to
express
the
graph
as
two
graphs.
This
may
not
be
acceptable
to
some
authors,
who
would
rather
express
the
information
as
one
graph.
Since,
by
definition,
disjoint
graphs
require
there
to
be
two
top-level
objects,
JSON-LD
utilizes
a
mechanism
that
allows
disjoint
graphs
to
be
expressed
using
a
single
graph.
</ins></p><p><ins class="diff-new">
Assume
the
following
RDF
graph:
</ins></p><pre class="example"><ins class="diff-new">
&lt;http://example.org/people#john&gt; 
   &lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&gt;
      &lt;http://xmlns.com/foaf/0.1/Person&gt; .
&lt;http://example.org/people#jane&gt; 
   &lt;http://www.w3.org/1999/02/22-rdf-syntax-ns#type&gt;
      &lt;http://xmlns.com/foaf/0.1/Person&gt; .
&lt;/section&gt;
</ins></pre><p><ins class="diff-new">
Since
the
two
subjects
are
entirely
disjoint
with
one
another,
it
is
impossible
to
express
the
RDF
graph
above
using
a
single
JSON-LD
associative
array.
</ins></p><p><ins class="diff-new">
In
JSON-LD,
one
can
use
the
subject
to
express
disjoint
graphs
as
a
single
graph:
</ins></p><pre class="example"><ins class="diff-new">
{
  "#": { "foaf": "http://xmlns.com/foaf/0.1/" },
  "@": 
  [
    {
      "@": "&lt;http://example.org/people#john&gt;",
      "a": "foaf:Person"
    },
    {
      "@": "&lt;http://example.org/people#jane&gt;",
      "a": "foaf:Person"
    }
  ]
}
</ins></pre></div><div class="appendix section" id="acknowledgements"><h3><span class="secno"><ins class="diff-new">
10.2
</ins></span><ins class="diff-new">
Acknowledgements
</ins></h3>
<p>
The
editor
would
like
to
thank
Mark
Birbeck,
who
provided
a
great
deal
of
the
rationale
and
reasoning
behind
the
JSON-LD
work
via
his
work
on
RDFj,
<ins class="diff-new">Dave
Longley
who
reviewed
and
provided
feedback
on
the
overall
specification
and
contexts,
</ins>
and
Ian
Davis,
who
created
RDF/JSON.
</p>
</div>
</div>
<div id="references" class="appendix section">
<h2>
<span class="secno">
<del class="diff-old">B.
</del>
<ins class="diff-chg">A.
</ins>
</span>
References
</h2>
<div id="normative-references" class="section">
<h3>
<span class="secno">
<del class="diff-old">B.1
</del>
<ins class="diff-chg">A.1
</ins>
</span>
Normative
references
</h3>
<dl class="bibliography">
<dt id="bib-BCP47">
<ins class="diff-new">[BCP47]
</ins></dt><dd><ins class="diff-new">
A.
Phillips,
M.
Davis.
</ins><a href="http://tools.ietf.org/rfc/bcp/bcp47.txt"><cite><ins class="diff-new">
Tags
for
Identifying
Languages
</ins></cite></a><ins class="diff-new">
September
2009.
IETF
Best
Current
Practice.
URL:
</ins><a href="http://tools.ietf.org/rfc/bcp/bcp47.txt"><ins class="diff-new">
http://tools.ietf.org/rfc/bcp/bcp47.txt
</ins></a></dd>
<dt id="bib-RFC4627">
[RFC4627]
</dt>
<dd>
D.
Crockford
<a href="http://www.ietf.org/rfc/rfc4627.txt">
The
application/json
Media
Type
for
JavaScript
Object
Notation
(JSON)
</a>
July
2006.
Internet
RFC
4627.
URL:
<a href="http://www.ietf.org/rfc/rfc4627.txt">
http://www.ietf.org/rfc/rfc4627.txt
</a>
</dd>
</dl>
</div>
<div id="informative-references" class="section">
<h3>
<span class="secno">
<del class="diff-old">B.2
</del>
<ins class="diff-chg">A.2
</ins>
</span>
Informative
references
</h3>
<dl class="bibliography">
<dt id="bib-MICRODATA">
[MICRODATA]
</dt>
<dd>
Ian
Hickson;
et
al.
<a href="http://www.w3.org/TR/microdata/">
<cite>
Microdata
</cite>
</a>
04
March
2010.
W3C
Working
Draft.
URL:
<a href="http://www.w3.org/TR/microdata/">
http://www.w3.org/TR/microdata/
</a>
</dd>
<dt id="bib-MICROFORMATS">
[MICROFORMATS]
</dt>
<dd>
<a href="http://microformats.org">
<cite>
Microformats
</cite>
</a>.
URL:
<a href="http://microformats.org">
http://microformats.org
</a>
</dd>
<dt id="bib-RDFA-CORE">
[RDFA-CORE]
</dt>
<dd>
Shane
McCarron;
et
al.
<a href="http://www.w3.org/TR/2010/WD-rdfa-core-20100803">
<cite>
RDFa
Core
1.1:
Syntax
and
processing
rules
for
embedding
RDF
through
attributes.
</cite>
</a>
3
August
2010.
W3C
Working
Draft.
URL:
<a href="http://www.w3.org/TR/2010/WD-rdfa-core-20100803">
http://www.w3.org/TR/2010/WD-rdfa-core-20100803
</a>
</dd>
</dl>
</div>
</div>
</body>
</html>
